package com.sunye.rabbit_mq_2;
import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * amqp配置.
 */
@Configuration
public class RabbitBeanConfig {

    /**
     * 创建队列
     *
     * @return 返回创建的队列
     */
    @Bean("messageQueue")
    public Queue messageQueue() {
        // 创建持久队列且不自动确认
        // 消息持久化，必须Exchange,Queue，投递模式deliveryModel=2,三者完全匹配，才会进行持久化存储
        return new Queue("messageQueue", true, false, false);
    }


    /**
     * 创建队列
     *
     * @return 返回创建的队列
     */
    @Bean("messageQueue2")
    public Queue messageQueue2() {
        // 创建持久队列且不自动确认
        // 消息持久化，必须Exchange,Queue，投递模式deliveryModel=2,三者完全匹配，才会进行持久化存储
        return new Queue("messageQueue2", true, false, false);
    }



    /**
     * 创建广播创建交换机
     *
     * @return 返回广播交换机
     */
    @Bean("fanoutExchange")
    public Exchange messageFanoutExchange() {
        return ExchangeBuilder.fanoutExchange("fanoutExchange").durable(true).build();
    }


    /**
     * 交换机和路由 队列1的绑定
     *
     * @param queue    需要绑定的队列
     * @param exchange 需要绑定的交换机
     * @return 返回绑定
     */
    @Bean
    public Binding buildFanoutMessage(@Qualifier("messageQueue") Queue queue, @Qualifier("fanoutExchange") Exchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with("routingkey").noargs();
    }



    /**
     * 交换机和路由 队列2的绑定
     *
     * @param queue    需要绑定的队列
     * @param exchange 需要绑定的交换机
     * @return 返回绑定
     */
    @Bean
    public Binding buildFanoutMessage2(@Qualifier("messageQueue2") Queue queue, @Qualifier("fanoutExchange") Exchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with("").noargs();
    }




    /**
     * 创建路由交换机
     *
     * @return 返回交换机
     */
    @Bean("directExchange")
    public Exchange directExchange() {
        return ExchangeBuilder.topicExchange("directExchange").durable(true).build();
    }


    /**
     * 创建队列
     *
     * @return 返回创建的队列
     */
    @Bean("directQueue")
    public Queue directQueue() {
        // 创建持久队列且不自动确认
        // 消息持久化，必须Exchange,Queue，投递模式deliveryModel=2,三者完全匹配，才会进行持久化存储
        return new Queue("directQueue", true, false, false);
    }


    /**
     * 创建队列
     *
     * @return 返回创建的队列
     */
    @Bean("directQueue2")
    public Queue directQueue2() {
        // 创建持久队列且不自动确认
        // 消息持久化，必须Exchange,Queue，投递模式deliveryModel=2,三者完全匹配，才会进行持久化存储
        return new Queue("directQueue2", true, false, false);
    }



    /**
     * 交换机和路由 队列1的绑定
     *
     * @param queue    需要绑定的队列
     * @param exchange 需要绑定的交换机
     * @return 返回绑定
     */
    @Bean
    public Binding buildTopicMessage(@Qualifier("directQueue") Queue queue, @Qualifier("directExchange") Exchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with("orange").noargs();
    }

    /**
     * 交换机和路由 队列1的绑定
     *
     * @param queue    需要绑定的队列
     * @param exchange 需要绑定的交换机
     * @return 返回绑定
     */
    @Bean
    public Binding buildTopicMessage2(@Qualifier("directQueue") Queue queue, @Qualifier("directExchange") Exchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with("blue").noargs();
    }


    /**
     * 交换机和路由 队列2的绑定
     *
     * @param queue    需要绑定的队列
     * @param exchange 需要绑定的交换机
     * @return 返回绑定
     */
    @Bean
    public Binding buildTopicMessage3(@Qualifier("directQueue2") Queue queue, @Qualifier("directExchange") Exchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with("red").noargs();
    }



    //动态路由
    private static  final String TOPIC_QUEUE01 = "topicQueue01";
    private static  final String TOPIC_QUEUE02 = "topicQueue02";
    private static  final String TOPIC_EXCHANGE = "topicExchange";
    private static  final String ROUTE_KEY01 = "#.queue.#";
    private static  final String ROUTE_KEY02 = "*.queue.#";


    @Bean
    public Queue queue01(){
        return new Queue(TOPIC_QUEUE01,true);//持久化
    }


    @Bean
    public Queue queue02(){
        return new Queue(TOPIC_QUEUE02,true);//持久化
    }


    @Bean
    public TopicExchange topicExchange(){
        return new TopicExchange(TOPIC_EXCHANGE);
    }

    @Bean
    public Binding binding1(){
        return  BindingBuilder.bind(queue01()).to(topicExchange()).with(ROUTE_KEY01);
    }

    @Bean
    public Binding binding2(){
        return BindingBuilder.bind(queue02()).to(topicExchange()).with(ROUTE_KEY02);
    }

}
